var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var $1$EventManager = require("EventManager");
var i = cc__importDefault($1$EventManager);
var $GameEventType = require("GameEventType");
var $zqcc_OverallSystem = require("zqcc_OverallSystem");
var def_Loader = function () {
  function _ctor() { }
  _ctor.showProgressBar = function (t) {
    // 确保 t 有默认值
    if (t === undefined) {
      t = 0; // 若未定义，则将 t 设置为 0
    }

    this.showMask(); // 显示遮罩
    i.default.emit($GameEventType.EventType.LoadAssetEvent.showProgress, t); // 发送加载进度事件
  };
  _ctor.updateProgress = function (t, e) {
    // 计算进度比例
    let o = t / e; // 计算当前进度比例

    // 限制进度比例在 0 到 1 之间
    if (o > 1) {
      o = 1; // 如果超过1，则将其限制为1
    }

    // 发送更新进度事件
    i.default.emit($GameEventType.EventType.LoadAssetEvent.updateProgress, o);
  };
  _ctor.hideProgressBar = function (t) {
    // 确保 t 有默认值
    if (t === undefined) {
      t = 1; // 若未定义，则将 t 设置为 1
    }

    // 发送隐藏进度事件
    i.default.emit($GameEventType.EventType.LoadAssetEvent.hideProgress);

    // 隐藏遮罩并传递 t 作为参数
    this.hideMask(t);
  };
  _ctor.showMask = function (t) {
    // 确保 t 有默认值
    if (t === undefined) {
      t = 1; // 若未定义，则将 t 设置为 1
    }

    // 发送显示触摸遮罩事件
    i.default.emit($GameEventType.EventType.UIEvent.showTouchMask, t);
  };
  _ctor.hideMask = function (t) {
    // 确保 t 有默认值
    if (t === undefined) {
      t = 1
    }
    // 取消显示触摸遮罩事件
    i.default.emit($GameEventType.EventType.UIEvent.hideTouchMask, t);
  };
  _ctor.loadBundle = function (t, e, o, n) {
    if (undefined === o) o = false;
    if (undefined === n) n = false
    this.loadSubpackage(t, e, o, n);
  };
  _ctor.loadSubpackage = function (t, e, o, n) {
    // 确保 o 和 n 有默认值
    if (o === undefined) {
      o = false; // 若未定义，则将 o 设置为 false
    }
    if (n === undefined) {
      n = false; // 若未定义，则将 n 设置为 false
    }

    let i = this.subpackageRecords[t]; // 获取子包记录

    if (!i) {
      i = new l(t, e, o); // 创建新的子包记录
      this.subpackageRecords[t] = i; // 保存到记录中
    }

    // 根据子包状态进行处理
    switch (i.state) {
      case c.inited:
        if (o) this.showSubpackageProgress(); // 显示加载进度
        if (n && this.subpackageSequence.length > 0) {
          this.subpackageSequence.splice(1, 0, t); // 插入到序列
          i.enterSequence(); // 进入序列
        } else {
          this.subpackageSequence.push(t); // 添加到序列
          if (this.subpackageSequence.length > 1) {
            i.enterSequence(); // 进入序列
          } else {
            this._loadSubpackage(t); // 加载子包
          }
        }
        break;

      case c.waiting:
        if (o) this.showSubpackageProgress(); // 显示加载进度
        i.pushCb(e, o); // 保存回调
        if (n && this.subpackageSequence.length > 0) {
          const r = this.subpackageSequence.indexOf(t);
          if (r > 1) {
            this.subpackageSequence.splice(r, 1); // 移动到序列开头
            this.subpackageSequence.splice(1, 0, t);
            i.enterSequence(); // 进入序列
          }
        }
        break;

      case c.turnTo:
        if (o) this.showSubpackageProgress(); // 显示加载进度
        i.pushCb(e, o); // 保存回调
        this._loadSubpackage(t); // 加载子包
        break;

      case c.loading:
        if (o) this.showSubpackageProgress(); // 显示加载进度
        i.pushCb(e, o); // 保存回调
        break;

      case c.finished:
        setTimeout(() => {
          if (e) e(); // 回调
        }, 0);
    }
  };
  _ctor._loadSubpackage = function (t, e) {
    const o = this; // 保持上下文的引用
    if (e === undefined) {
      e = false; // 若未定义，则将 e 设置为 false
    }

    // 开始加载子包
    this.subpackageRecords[t].loadStart();

    // 加载子包
    cc.assetManager.loadBundle(t, function (n) {
      // 如果加载成功且 e 为 false，则开始加载子包
      if (n && !e) {
        o._loadSubpackage(t, true);
      }

      // 检查加载结果
      if (n) {
        console.error("子包加载出错：", t); // 输出错误信息
        $zqcc_OverallSystem.sers().uiSrv.showMessage("资源加载错误,请检查网络是否畅通~"); // 显示错误消息
        i.default.emit($GameEventType.EventType.DirectorEvent.loadingError); // 发出加载错误事件
        console.error(n); // 输出错误详情

        // 更新子包序列和记录
        const s = o.subpackageSequence.indexOf(t);
        o.subpackageSequence.splice(s, 1); // 从序列中移除
        o.subpackageRecords[t] = null; // 清除记录
        o.hideSubpackageProgress(); // 隐藏加载进度
        return void $zqcc_OverallSystem.sers().uiSrv.hideLoding(); // 隐藏加载界面
      }

      cc.log("子包加载完成：", t); // 输出加载完成信息

      // 更新子包序列和记录
      const c = o.subpackageSequence.indexOf(t);
      o.subpackageSequence.splice(c, 1); // 从序列中移除
      o.hideSubpackageProgress(); // 隐藏加载进度
      o.subpackageRecords[t].loadFinish(); // 完成加载记录

      // 如果还有其他子包，继续加载下一个
      if (o.subpackageSequence.length > 0) {
        const l = o.subpackageSequence[0];
        const u = o.subpackageRecords[l];
        if (u) {
          u.turnToLoad(); // 转到加载状态
        }
        o.loadSubpackage(l, null, !!u.maskCount); // 加载下一个子包
      }
    });
  };
  _ctor.showSubpackageProgress = function () {
    // 检查子包进度计时器是否为 null
    if (this.subpackageProgressTimer === null) {
      this.showProgressBar(); // 显示进度条
      this.subpackageProgress = 0; // 初始化进度值
      // 启动定时器以更新子包进度
      this.subpackageProgressTimer = setInterval(this.updateSubpackageProgress.bind(this), 100);
    }
  };
  _ctor.updateSubpackageProgress = function () {
    // 增加子包的进度
    this.subpackageProgress += 0.03; // 增加进度值

    // 如果进度达到或超过 1，则重置为 0
    if (this.subpackageProgress >= 1) {
      this.subpackageProgress = 0;
    }

    // 发送更新进度事件
    i.default.emit($GameEventType.EventType.LoadAssetEvent.updateProgress, this.subpackageProgress);
  };
  _ctor.hideSubpackageProgress = function () {
    // 检查子包进度计时器是否存在
    if (this.subpackageProgressTimer !== null) {
      let totalMaskCount = 0; // 初始化总遮罩计数

      // 倒序遍历子包顺序
      for (let i = this.subpackageSequence.length - 1; i >= 0; --i) {
        totalMaskCount += this.subpackageRecords[this.subpackageSequence[i]].maskCount; // 累加遮罩计数
      }

      // 如果总遮罩计数为 0，清除计时器并隐藏进度条
      if (totalMaskCount === 0) {
        clearInterval(this.subpackageProgressTimer); // 停止计时器
        this.subpackageProgressTimer = null; // 重置计时器
        this.subpackageProgress = 0; // 重置进度
        this.hideProgressBar(); // 隐藏进度条
      }
    }
  };
  _ctor.loadRes = function (t, e, o) {
    const n = this; // 保持上下文的引用

    if (this.singleAsset[t]) {
      // 如果单个资产已存在，使用 setTimeout 以确保 e 在下一个事件循环中执行
      setTimeout(() => {
        e(n.singleAsset[t]);
      }, 0);
    } else {
      // 确保 o 有默认值
      if (o === undefined) {
        o = true;
      }

      // 如果 o 为真，则显示遮罩
      if (o) {
        this.showMask();
      }

      // 加载资源
      cc.loader.loadRes(t, function (error, resource) {
        if (o) {
          n.hideMask(); // 加载完成后隐藏遮罩
        }

        // 如果加载出错，输出错误信息并返回 null
        if (error) {
          cc.error(error.message || error);
          return void e(null);
        }

        // 保存加载的资源并调用回调
        n.singleAsset[t] = resource;
        e(resource);
      });
    }
  };
  _ctor.loadResDir = function (t, e, o, n) {
    const i = this; // 保持上下文的引用

    if (this.dirAsset[t]) {
      // 如果目录资产已存在，使用 setTimeout 确保回调在下一个事件循环中执行
      setTimeout(() => {
        e(i.dirAsset[t]);
      }, 0);
    } else {
      let r = null; // 初始化资源路径
      let n;

      // 设置 n 的值，根据 o 的类型
      if (o === undefined) {
        n = true; // 默认值为 true
      } else if (typeof o === "boolean") {
        n = !!o;
      } else {
        r = o; // 如果 o 不是 undefined 或布尔值，赋值给 r
        n = n === undefined ? true : n; // 确保 n 默认是 true
      }

      if (n) {
        this.showProgressBar(); // 显示进度条
      }

      // 加载资源目录
      const loadResources = (resourcePath, callback) => {
        cc.loader.loadResDir(t, resourcePath, this.updateProgress.bind(this), callback);
      };

      const callback = (error, resources, assetNames) => {
        if (n) {
          i.hideProgressBar(); // 隐藏进度条
        }

        if (error) {
          cc.log(error); // 记录错误
          return void e(null); // 回调 null 表示错误
        }

        // 保存加载的资源
        i.dirAsset[t] = resources;
        for (let s = resources.length - 1; s >= 0; --s) {
          i.singleAsset[assetNames[s]] = resources[s]; // 更新单个资产
        }
        e(i.dirAsset[t]); // 调用回调
      };

      if (r) {
        loadResources(r, callback); // 有指定路径时执行
      } else {
        loadResources(undefined, callback); // 默认路径
      }
    }
  };
  _ctor.loadResArray = function (t, e, o) {
    const n = this; // 保持上下文的引用
    const i = []; // 已加载的资产数组
    const r = []; // 待加载的资产数组

    // 倒序遍历资产列表
    for (let a = t.length - 1; a >= 0; --a) {
      const s = this.getAsset(t[a]); // 获取资产
      if (s) {
        i.push(s); // 如果已加载，添加到已加载数组
      } else {
        r.push(t[a]); // 如果未加载，添加到待加载数组
      }
    }

    // 如果待加载数组不为空
    if (r.length !== 0) {
      if (o === undefined) {
        o = true; // 确保 o 默认值为 true
      }

      if (o) {
        this.showProgressBar(); // 显示进度条
      }

      // 加载资源数组
      cc.loader.loadResArray(r, this.updateProgress.bind(this), function (error, assets) {
        if (o) {
          n.hideProgressBar(); // 加载结束后隐藏进度条
        }

        if (error) {
          cc.log(error); // 记录错误
          return void e(null); // 回调 null 表示加载错误
        }

        // 处理加载的资产
        if (Array.isArray(assets)) {
          for (let s = r.length - 1; s >= 0; --s) {
            n.singleAsset[r[s]] = assets[s]; // 将资产保存到单个资产中
            i.push(assets[s]); // 添加到已加载数组
          }
        } else {
          n.singleAsset[r[0]] = assets; // 单个资产
          i.push(assets); // 添加到已加载数组
        }

        e(i); // 调用回调，返回已加载的资产数组
      });
    } else {
      // 如果没有待加载的资产
      setTimeout(() => {
        e(i); // 直接调用回调
      }, 0);
    }
  };
  _ctor.getAsset = function (t) {
    // 检查是否已加载资产
    if (this.singleAsset[t]) {
      return this.singleAsset[t]; // 返回已加载的资产
    } else {
      console.warn("尚未加载资源：", t); // 输出警告信息
      return null; // 返回 null 表示未加载
    }
  };
  _ctor.loadBundleRes = function (t, e, o, n, i) {
    const r = this; // 保存上下文的引用
    const bundle = cc.assetManager.getBundle(t); // 获取资源包

    // 检查资源包是否加载
    if (!bundle) {
      console.error("资源包 " + t + " 尚未加载，无法获取资源:", e);
      return void o(null); // 返回 null 表示无法获取资源
    }

    let s = null; // 初始化路径变量
   

    // 根据 n 的类型设置 i 和 s
    if (n === undefined) {
      i = true; // 默认值为 true
    } else if (typeof n === "boolean") {
      i = !!n; // 强制转换为布尔值
    } else {
      s = n; // 如果 n 是非布尔值，则将其赋给 s
      i = i === undefined ? true : i; // 如果 i 未定义，则默认为 true
    }

    if (i) {
      this.showMask(); // 根据标识显示遮罩
    }

    // 加载资源
    if (s !== null) {
      bundle.load(e, s, function (error, resource) {
        if (i) r.hideMask(); // 加载完成后隐藏遮罩
        if (error) {
          cc.error(error.message || error); // 输出错误信息
          return void o(null); // 返回 null 表示加载错误
        }
        o(resource); // 调用回调，返回加载的资源
      });
    } else {
      bundle.load(e, function (error, resource) {
        if (i) r.hideMask(); // 加载完成后隐藏遮罩
        if (error) {
          cc.log(error.message || error); // 输出警告信息
          return void o(null); // 返回 null 表示加载错误
        }
        o(resource); // 调用回调，返回加载的资源
      });
    }
  };
  _ctor.loadBundleArray = function (t, e, o, n, i) {
    const r = this; // 保存上下文的引用
    const bundle = cc.assetManager.getBundle(t); // 获取资源包

    // 检查资源包是否加载
    if (!bundle) {
      console.error("资源包 " + t + " 尚未加载，无法获取资源数组:", e);
      return void o(null); // 返回 null 表示无法获取资源
    }

    let s = null; // 初始化资源路径变量

    // 根据 n 的类型设置 i 和 s
    if (n === undefined) {
      i = true; // 默认值为 true
    } else if (typeof n === "boolean") {
      i = !!n; // 强制转换为布尔值
    } else {
      s = n; // 如果 n 是非布尔值，则将其赋给 s
      i = i === undefined ? true : i; // 如果 i 未定义，则默认为 true
    }

    if (i) {
      this.showProgressBar(); // 根据标识显示进度条
    }

    // 加载资源
    if (s) {
      // 如果提供了资源路径
      bundle.load(e, s, this.updateProgress.bind(this), function (error, resource) {
        if (i) r.hideProgressBar(); // 加载完成后隐藏进度条
        if (error) {
          cc.error(error.message || error); // 输出错误信息
          return void o(null); // 返回 null 表示加载错误
        }
        o(resource); // 调用回调，返回加载的资源
      });
    } else {
      // 如果没有提供资源路径
      bundle.load(e, this.updateProgress.bind(this), function (error, resource) {
        if (i) r.hideProgressBar(); // 加载完成后隐藏进度条
        if (error) {
          cc.error(error.message || error); // 输出错误信息
          return void o(null); // 返回 null 表示加载错误
        }
        o(resource); // 调用回调，返回加载的资源
      });
    }
  };
  _ctor.loadBundleDir = function (t, e, o, n, i) {
    const r = this; // 保存上下文的引用
    const bundle = cc.assetManager.getBundle(t); // 获取资源包

    // 检查资源包是否已加载
    if (!bundle) {
      console.error("资源包 " + t + " 尚未加载，无法获取资源文件夹:", e);
      return void o(null); // 返回 null 表示无法获取资源
    }

    let s = null; // 初始化资源路径变量

    // 根据 n 的类型设置 i 和 s
    if (n === undefined) {
      i = true; // 默认值为 true
    } else if (typeof n === "boolean") {
      i = !!n; // 强制转换为布尔值
    } else {
      s = n; // 如果 n 是非布尔值，则将其赋给 s
      i = i === undefined ? true : i; // 如果 i 未定义，则默认为 true
    }

    if (i) {
      this.showProgressBar(); // 显示进度条
    }

    // 加载资源文件夹
    if (s) {
      // 如果提供了资源路径
      bundle.loadDir(e, s, this.updateProgress.bind(this), function (error, resources) {
        if (i) r.hideProgressBar(); // 加载完成后隐藏进度条
        if (error) {
          cc.log(error); // 输出错误日志
          return void o(null); // 返回 null 表示加载错误
        }
        o(resources); // 调用回调，返回加载的资源
      });
    } else {
      // 如果没有提供资源路径
      bundle.loadDir(e, this.updateProgress.bind(this), function (error, resources) {
        if (i) r.hideProgressBar(); // 加载完成后隐藏进度条
        if (error) {
          cc.log(error); // 输出错误日志
          return void o(null); // 返回 null 表示加载错误
        }
        o(resources); // 调用回调，返回加载的资源
      });
    }
  };
  _ctor.loadBundleScene = function (t, e, o, n) {
    const i = this; // 保存上下文的引用
    const bundle = cc.assetManager.getBundle(t); // 获取资源包

    // 检查资源包是否已加载
    if (!bundle) {
      console.error("资源包 " + t + " 尚未加载，无法加载场景:", e);
      return void o(null); // 返回 null 表示无法加载
    }

    // 确保 n 有默认值
    if (n === undefined) {
      n = true; // 默认值为 true
    }

    if (n) {
      this.showProgressBar(); // 在有进度标识的情况下显示进度条
    }

    // 加载场景
    bundle.loadScene(e, this.updateProgress.bind(this), function (error, scene) {
      if (n) {
        i.hideProgressBar(); // 加载完成后隐藏进度条
      }

      if (error) {
        console.error(error); // 输出错误信息
      } else {
        o(scene); // 调用回调，返回加载的场景
      }
    });
  };
  _ctor.preLoadBundleRes = function (t, e, o) {
    const bundle = cc.assetManager.getBundle(t); // 获取资源包

    // 检查资源包是否存在
    if (bundle) {
      // 根据 o 的定义决定预加载方式
      if (o === undefined) {
        bundle.preload(e); // 不传递 o，直接预加载
      } else {
        bundle.preload(e, o); // 传递 o，执行预加载
      }
    }
  };
  _ctor.preLoadBundleArray = function (t, e, o) {
    const bundle = cc.assetManager.getBundle(t); // 获取资源包

    // 检查资源包是否存在
    if (bundle) {
      // 根据 o 的值选择预加载方式
      if (o === undefined) {
        bundle.preload(e); // 不传递 o，执行预加载
      } else {
        bundle.preload(e, o); // 传递 o，执行预加载
      }
    }
  };
  _ctor.preLoadBundleDir = function (t, e, o) {
    const bundle = cc.assetManager.getBundle(t); // 获取资源包

    // 检查资源包是否存在
    if (bundle) {
      // 根据 o 的值选择预加载方式
      if (o === undefined) {
        bundle.preloadDir(e); // 不传递 o，执行预加载
      } else {
        bundle.preloadDir(e, o); // 传递 o，执行预加载
      }
    }
  };
  _ctor.preLoadBundleScene = function (t, e) {
    var o = cc.assetManager.getBundle(t);
    if (o) {
      o.preloadScene(e);
    }
  };
  _ctor.dirAsset = {};
  _ctor.singleAsset = {};
  _ctor.subpackageRecords = {};
  _ctor.subpackageSequence = [];
  _ctor.subpackageProgressTimer = null;
  _ctor.subpackageProgress = 0;
  return _ctor;
}();
exports.default = def_Loader;
var c;
var l = function () {
  function t(t, e, o) {
    this.name = t;
    this.state = c.inited;
    this.cbs = [];
    e && this.pushCb(e);
    this.maskCount = o ? 1 : 0;
  }
  t.prototype.pushCb = function (t, e) {
    t && this.cbs.push(t);
    e && this.maskCount++;
  };
  t.prototype.enterSequence = function () {
    this.state = c.waiting;
  };
  t.prototype.loadStart = function () {
    this.state = c.loading;
  };
  t.prototype.loadFinish = function () {
    for (; this.cbs.length > 0;) {
      var t = this.cbs.shift();
      t && t();
    }
    this.state = c.finished;
    this.maskCount = 0;
  };
  t.prototype.turnToLoad = function () {
    this.state = c.turnTo;
  };
  return t;
}();
(function (t) {
  t[t.inited = 1] = "inited";
  t[t.waiting = 2] = "waiting";
  t[t.loading = 3] = "loading";
  t[t.finished = 4] = "finished";
  t[t.turnTo = 5] = "turnTo";
})(c || (c = {}));